/*
Copyright 2023 The Malachite Authors.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

/* automatically generated by rust-bindgen 0.59.1 */

#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct byteperf_config_malachite {
    pub command: ::std::os::raw::c_int,
    pub xml_root: *mut ::std::os::raw::c_char,
    pub xml_module: *mut ::std::os::raw::c_char,
    pub priority: ::std::os::raw::c_int,
    pub duration: ::std::os::raw::c_int,
    pub interval: ::std::os::raw::c_int,
    pub format: ::std::os::raw::c_int,
    pub cpus: [::std::os::raw::c_uint; 256usize],
    pub cpu_num: ::std::os::raw::c_uint,
    pub cgroups: [[::std::os::raw::c_char; 255usize]; 256usize],
    pub cgroup_num: ::std::os::raw::c_uint,
}
#[test]
fn bindgen_test_layout_byteperf_config_malachite() {
    assert_eq!(
        ::std::mem::size_of::<byteperf_config_malachite>(),
        66352usize,
        concat!("Size of: ", stringify!(byteperf_config_malachite))
    );
    assert_eq!(
        ::std::mem::align_of::<byteperf_config_malachite>(),
        8usize,
        concat!("Alignment of ", stringify!(byteperf_config_malachite))
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_config_malachite>())).command as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_config_malachite),
            "::",
            stringify!(command)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_config_malachite>())).xml_root as *const _ as usize
        },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_config_malachite),
            "::",
            stringify!(xml_root)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_config_malachite>())).xml_module as *const _ as usize
        },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_config_malachite),
            "::",
            stringify!(xml_module)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_config_malachite>())).priority as *const _ as usize
        },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_config_malachite),
            "::",
            stringify!(priority)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_config_malachite>())).duration as *const _ as usize
        },
        28usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_config_malachite),
            "::",
            stringify!(duration)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_config_malachite>())).interval as *const _ as usize
        },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_config_malachite),
            "::",
            stringify!(interval)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_config_malachite>())).format as *const _ as usize
        },
        36usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_config_malachite),
            "::",
            stringify!(format)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<byteperf_config_malachite>())).cpus as *const _ as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_config_malachite),
            "::",
            stringify!(cpus)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_config_malachite>())).cpu_num as *const _ as usize
        },
        1064usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_config_malachite),
            "::",
            stringify!(cpu_num)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_config_malachite>())).cgroups as *const _ as usize
        },
        1068usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_config_malachite),
            "::",
            stringify!(cgroups)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_config_malachite>())).cgroup_num as *const _ as usize
        },
        66348usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_config_malachite),
            "::",
            stringify!(cgroup_num)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct byteperf_hardware_malachite {
    pub psm_name: [::std::os::raw::c_char; 255usize],
    pub ip_addr: [::std::os::raw::c_char; 255usize],
    pub ipv6_addr: [::std::os::raw::c_char; 255usize],
    pub host_name: [::std::os::raw::c_char; 255usize],
    pub arch_name: [::std::os::raw::c_char; 255usize],
    pub platform_name: [::std::os::raw::c_char; 255usize],
}
#[test]
fn bindgen_test_layout_byteperf_hardware_malachite() {
    assert_eq!(
        ::std::mem::size_of::<byteperf_hardware_malachite>(),
        1530usize,
        concat!("Size of: ", stringify!(byteperf_hardware_malachite))
    );
    assert_eq!(
        ::std::mem::align_of::<byteperf_hardware_malachite>(),
        1usize,
        concat!("Alignment of ", stringify!(byteperf_hardware_malachite))
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_hardware_malachite>())).psm_name as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_hardware_malachite),
            "::",
            stringify!(psm_name)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_hardware_malachite>())).ip_addr as *const _ as usize
        },
        255usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_hardware_malachite),
            "::",
            stringify!(ip_addr)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_hardware_malachite>())).ipv6_addr as *const _ as usize
        },
        510usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_hardware_malachite),
            "::",
            stringify!(ipv6_addr)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_hardware_malachite>())).host_name as *const _ as usize
        },
        765usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_hardware_malachite),
            "::",
            stringify!(host_name)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_hardware_malachite>())).arch_name as *const _ as usize
        },
        1020usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_hardware_malachite),
            "::",
            stringify!(arch_name)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_hardware_malachite>())).platform_name as *const _
                as usize
        },
        1275usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_hardware_malachite),
            "::",
            stringify!(platform_name)
        )
    );
}

#[repr(C)]
#[derive(Debug, Copy, Clone)]
// TODO: instructions/cycle should be u64
pub struct byteperf_cpu_buffer_malachite {
    pub cpu: ::std::os::raw::c_uint,
    pub cpi: f64,
    pub instructions: ::std::os::raw::c_ulong,
    pub cycles: ::std::os::raw::c_ulong,
    pub l3_misses: ::std::os::raw::c_ulong,
    pub utilization: f64,
}
#[test]
fn bindgen_test_layout_byteperf_cpu_buffer_malachite() {
    assert_eq!(
        ::std::mem::size_of::<byteperf_cpu_buffer_malachite>(),
        48usize,
        concat!("Size of: ", stringify!(byteperf_cpu_buffer_malachite))
    );
    assert_eq!(
        ::std::mem::align_of::<byteperf_cpu_buffer_malachite>(),
        8usize,
        concat!("Alignment of ", stringify!(byteperf_cpu_buffer_malachite))
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_cpu_buffer_malachite>())).cpu as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_cpu_buffer_malachite),
            "::",
            stringify!(cpu)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_cpu_buffer_malachite>())).cpi as *const _ as usize
        },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_cpu_buffer_malachite),
            "::",
            stringify!(cpi)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_cpu_buffer_malachite>())).instructions as *const _
                as usize
        },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_cpu_buffer_malachite),
            "::",
            stringify!(instructions)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_cpu_buffer_malachite>())).cycles as *const _ as usize
        },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_cpu_buffer_malachite),
            "::",
            stringify!(cycles)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_cpu_buffer_malachite>())).l3_misses as *const _ as usize
        },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_cpu_buffer_malachite),
            "::",
            stringify!(l3_misses)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_cpu_buffer_malachite>())).utilization as *const _
                as usize
        },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_cpu_buffer_malachite),
            "::",
            stringify!(utilization)
        )
    );
}

#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct byteperf_cgroup_buffer_malachite {
    pub name: [::std::os::raw::c_char; 255usize],
    pub numa: [::std::os::raw::c_char; 10usize],
    pub core_num: ::std::os::raw::c_int,
    pub cpi: f64,
    pub instructions: f64,
    pub cycles: f64,
    pub l3_misses: f64,
    pub utilization: f64,
}
#[test]
fn bindgen_test_layout_byteperf_cgroup_buffer_malachite() {
    assert_eq!(
        ::std::mem::size_of::<byteperf_cgroup_buffer_malachite>(),
        312usize,
        concat!("Size of: ", stringify!(byteperf_cgroup_buffer_malachite))
    );
    assert_eq!(
        ::std::mem::align_of::<byteperf_cgroup_buffer_malachite>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(byteperf_cgroup_buffer_malachite)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_cgroup_buffer_malachite>())).name as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_cgroup_buffer_malachite),
            "::",
            stringify!(name)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_cgroup_buffer_malachite>())).numa as *const _ as usize
        },
        255usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_cgroup_buffer_malachite),
            "::",
            stringify!(numa)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_cgroup_buffer_malachite>())).core_num as *const _
                as usize
        },
        268usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_cgroup_buffer_malachite),
            "::",
            stringify!(core_num)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_cgroup_buffer_malachite>())).cpi as *const _ as usize
        },
        272usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_cgroup_buffer_malachite),
            "::",
            stringify!(cpi)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_cgroup_buffer_malachite>())).instructions as *const _
                as usize
        },
        280usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_cgroup_buffer_malachite),
            "::",
            stringify!(instructions)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_cgroup_buffer_malachite>())).cycles as *const _ as usize
        },
        288usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_cgroup_buffer_malachite),
            "::",
            stringify!(cycles)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_cgroup_buffer_malachite>())).l3_misses as *const _
                as usize
        },
        296usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_cgroup_buffer_malachite),
            "::",
            stringify!(l3_misses)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_cgroup_buffer_malachite>())).utilization as *const _
                as usize
        },
        304usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_cgroup_buffer_malachite),
            "::",
            stringify!(utilization)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct byteperf_l3cache_buffer_malachite {
    pub name: [::std::os::raw::c_char; 255usize],
    pub socket: ::std::os::raw::c_int,
    pub numa_id: ::std::os::raw::c_uint,
    pub l3_miss_ratio: f64,
    pub l3_miss_latency: f64,
}
#[test]
fn bindgen_test_layout_byteperf_l3cache_buffer_malachite() {
    assert_eq!(
        ::std::mem::size_of::<byteperf_l3cache_buffer_malachite>(),
        280usize,
        concat!("Size of: ", stringify!(byteperf_l3cache_buffer_malachite))
    );
    assert_eq!(
        ::std::mem::align_of::<byteperf_l3cache_buffer_malachite>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(byteperf_l3cache_buffer_malachite)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_l3cache_buffer_malachite>())).name as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_l3cache_buffer_malachite),
            "::",
            stringify!(name)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_l3cache_buffer_malachite>())).socket as *const _
                as usize
        },
        256usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_l3cache_buffer_malachite),
            "::",
            stringify!(socket)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_l3cache_buffer_malachite>())).numa_id as *const _
                as usize
        },
        260usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_l3cache_buffer_malachite),
            "::",
            stringify!(numa_id)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_l3cache_buffer_malachite>())).l3_miss_ratio as *const _
                as usize
        },
        264usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_l3cache_buffer_malachite),
            "::",
            stringify!(l3_miss_ratio)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_l3cache_buffer_malachite>())).l3_miss_latency
                as *const _ as usize
        },
        272usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_l3cache_buffer_malachite),
            "::",
            stringify!(l3_miss_latency)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct byteperf_imc_buffer_malachite {
    pub name: [::std::os::raw::c_char; 255usize],
    pub socket: ::std::os::raw::c_int,
    pub numa_id: ::std::os::raw::c_uint,
    pub memory_read_bandwidth: f64,
    pub memory_write_bandwidth: f64,
    pub memory_total_bandwidth: f64,
    pub memory_idle_bandwidth: f64,
    pub memory_bandwidth_util: f64,
    pub memory_read_latency: f64,
    pub memory_write_latency: f64,
}
#[test]
fn bindgen_test_layout_byteperf_imc_buffer_malachite() {
    assert_eq!(
        ::std::mem::size_of::<byteperf_imc_buffer_malachite>(),
        320usize,
        concat!("Size of: ", stringify!(byteperf_imc_buffer_malachite))
    );
    assert_eq!(
        ::std::mem::align_of::<byteperf_imc_buffer_malachite>(),
        8usize,
        concat!("Alignment of ", stringify!(byteperf_imc_buffer_malachite))
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_imc_buffer_malachite>())).name as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_imc_buffer_malachite),
            "::",
            stringify!(name)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_imc_buffer_malachite>())).socket as *const _ as usize
        },
        256usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_imc_buffer_malachite),
            "::",
            stringify!(socket)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_imc_buffer_malachite>())).numa_id as *const _ as usize
        },
        260usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_imc_buffer_malachite),
            "::",
            stringify!(numa_id)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_imc_buffer_malachite>())).memory_read_bandwidth
                as *const _ as usize
        },
        264usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_imc_buffer_malachite),
            "::",
            stringify!(memory_read_bandwidth)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_imc_buffer_malachite>())).memory_write_bandwidth
                as *const _ as usize
        },
        272usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_imc_buffer_malachite),
            "::",
            stringify!(memory_write_bandwidth)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_imc_buffer_malachite>())).memory_total_bandwidth
                as *const _ as usize
        },
        280usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_imc_buffer_malachite),
            "::",
            stringify!(memory_total_bandwidth)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_imc_buffer_malachite>())).memory_idle_bandwidth
                as *const _ as usize
        },
        288usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_imc_buffer_malachite),
            "::",
            stringify!(memory_idle_bandwidth)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_imc_buffer_malachite>())).memory_bandwidth_util
                as *const _ as usize
        },
        296usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_imc_buffer_malachite),
            "::",
            stringify!(memory_bandwidth_util)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_imc_buffer_malachite>())).memory_read_latency
                as *const _ as usize
        },
        304usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_imc_buffer_malachite),
            "::",
            stringify!(memory_read_latency)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_imc_buffer_malachite>())).memory_write_latency
                as *const _ as usize
        },
        312usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_imc_buffer_malachite),
            "::",
            stringify!(memory_write_latency)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct byteperf_power_buffer_malachite {
    pub name: [::std::os::raw::c_char; 255usize],
    pub socket: ::std::os::raw::c_int,
    pub base_freq: f64,
    pub runtime_freq: f64,
    pub package_energy: f64,
    pub core_energy: f64,
    pub dram_energy: f64,
    pub package_energy_limit: f64,
    pub dram_energy_limit: f64,
}
#[test]
fn bindgen_test_layout_byteperf_power_buffer_malachite() {
    assert_eq!(
        ::std::mem::size_of::<byteperf_power_buffer_malachite>(),
        320usize,
        concat!("Size of: ", stringify!(byteperf_power_buffer_malachite))
    );
    assert_eq!(
        ::std::mem::align_of::<byteperf_power_buffer_malachite>(),
        8usize,
        concat!("Alignment of ", stringify!(byteperf_power_buffer_malachite))
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_power_buffer_malachite>())).name as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_power_buffer_malachite),
            "::",
            stringify!(name)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_power_buffer_malachite>())).socket as *const _ as usize
        },
        256usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_power_buffer_malachite),
            "::",
            stringify!(socket)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_power_buffer_malachite>())).base_freq as *const _
                as usize
        },
        264usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_power_buffer_malachite),
            "::",
            stringify!(base_freq)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_power_buffer_malachite>())).runtime_freq as *const _
                as usize
        },
        272usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_power_buffer_malachite),
            "::",
            stringify!(runtime_freq)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_power_buffer_malachite>())).package_energy as *const _
                as usize
        },
        280usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_power_buffer_malachite),
            "::",
            stringify!(package_energy)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_power_buffer_malachite>())).core_energy as *const _
                as usize
        },
        288usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_power_buffer_malachite),
            "::",
            stringify!(core_energy)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_power_buffer_malachite>())).dram_energy as *const _
                as usize
        },
        296usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_power_buffer_malachite),
            "::",
            stringify!(dram_energy)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_power_buffer_malachite>())).package_energy_limit
                as *const _ as usize
        },
        304usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_power_buffer_malachite),
            "::",
            stringify!(package_energy_limit)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_power_buffer_malachite>())).dram_energy_limit
                as *const _ as usize
        },
        312usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_power_buffer_malachite),
            "::",
            stringify!(dram_energy_limit)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct byteperf_iio_buffer_malachite {
    pub name: [::std::os::raw::c_char; 255usize],
    pub socket: ::std::os::raw::c_int,
    pub p0_read_bw: f64,
    pub p1_read_bw: f64,
    pub p2_read_bw: f64,
    pub p3_read_bw: f64,
    pub p4_read_bw: f64,
    pub p5_read_bw: f64,
    pub p6_read_bw: f64,
    pub p7_read_bw: f64,
    pub p0_write_bw: f64,
    pub p1_write_bw: f64,
    pub p2_write_bw: f64,
    pub p3_write_bw: f64,
    pub p4_write_bw: f64,
    pub p5_write_bw: f64,
    pub p6_write_bw: f64,
    pub p7_write_bw: f64,
    pub p0_latency: f64,
    pub p1_latency: f64,
    pub p2_latency: f64,
    pub p3_latency: f64,
    pub p4_latency: f64,
    pub p5_latency: f64,
    pub p6_latency: f64,
    pub p7_latency: f64,
}
#[test]
fn bindgen_test_layout_byteperf_iio_buffer_malachite() {
    assert_eq!(
        ::std::mem::size_of::<byteperf_iio_buffer_malachite>(),
        456usize,
        concat!("Size of: ", stringify!(byteperf_iio_buffer_malachite))
    );
    assert_eq!(
        ::std::mem::align_of::<byteperf_iio_buffer_malachite>(),
        8usize,
        concat!("Alignment of ", stringify!(byteperf_iio_buffer_malachite))
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_iio_buffer_malachite>())).name as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_iio_buffer_malachite),
            "::",
            stringify!(name)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_iio_buffer_malachite>())).socket as *const _ as usize
        },
        256usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_iio_buffer_malachite),
            "::",
            stringify!(socket)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_iio_buffer_malachite>())).p0_read_bw as *const _
                as usize
        },
        264usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_iio_buffer_malachite),
            "::",
            stringify!(p0_read_bw)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_iio_buffer_malachite>())).p1_read_bw as *const _
                as usize
        },
        272usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_iio_buffer_malachite),
            "::",
            stringify!(p1_read_bw)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_iio_buffer_malachite>())).p2_read_bw as *const _
                as usize
        },
        280usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_iio_buffer_malachite),
            "::",
            stringify!(p2_read_bw)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_iio_buffer_malachite>())).p3_read_bw as *const _
                as usize
        },
        288usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_iio_buffer_malachite),
            "::",
            stringify!(p3_read_bw)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_iio_buffer_malachite>())).p4_read_bw as *const _
                as usize
        },
        296usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_iio_buffer_malachite),
            "::",
            stringify!(p4_read_bw)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_iio_buffer_malachite>())).p5_read_bw as *const _
                as usize
        },
        304usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_iio_buffer_malachite),
            "::",
            stringify!(p5_read_bw)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_iio_buffer_malachite>())).p6_read_bw as *const _
                as usize
        },
        312usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_iio_buffer_malachite),
            "::",
            stringify!(p6_read_bw)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_iio_buffer_malachite>())).p7_read_bw as *const _
                as usize
        },
        320usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_iio_buffer_malachite),
            "::",
            stringify!(p7_read_bw)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_iio_buffer_malachite>())).p0_write_bw as *const _
                as usize
        },
        328usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_iio_buffer_malachite),
            "::",
            stringify!(p0_write_bw)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_iio_buffer_malachite>())).p1_write_bw as *const _
                as usize
        },
        336usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_iio_buffer_malachite),
            "::",
            stringify!(p1_write_bw)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_iio_buffer_malachite>())).p2_write_bw as *const _
                as usize
        },
        344usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_iio_buffer_malachite),
            "::",
            stringify!(p2_write_bw)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_iio_buffer_malachite>())).p3_write_bw as *const _
                as usize
        },
        352usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_iio_buffer_malachite),
            "::",
            stringify!(p3_write_bw)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_iio_buffer_malachite>())).p4_write_bw as *const _
                as usize
        },
        360usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_iio_buffer_malachite),
            "::",
            stringify!(p4_write_bw)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_iio_buffer_malachite>())).p5_write_bw as *const _
                as usize
        },
        368usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_iio_buffer_malachite),
            "::",
            stringify!(p5_write_bw)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_iio_buffer_malachite>())).p6_write_bw as *const _
                as usize
        },
        376usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_iio_buffer_malachite),
            "::",
            stringify!(p6_write_bw)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_iio_buffer_malachite>())).p7_write_bw as *const _
                as usize
        },
        384usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_iio_buffer_malachite),
            "::",
            stringify!(p7_write_bw)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_iio_buffer_malachite>())).p0_latency as *const _
                as usize
        },
        392usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_iio_buffer_malachite),
            "::",
            stringify!(p0_latency)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_iio_buffer_malachite>())).p1_latency as *const _
                as usize
        },
        400usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_iio_buffer_malachite),
            "::",
            stringify!(p1_latency)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_iio_buffer_malachite>())).p2_latency as *const _
                as usize
        },
        408usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_iio_buffer_malachite),
            "::",
            stringify!(p2_latency)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_iio_buffer_malachite>())).p3_latency as *const _
                as usize
        },
        416usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_iio_buffer_malachite),
            "::",
            stringify!(p3_latency)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_iio_buffer_malachite>())).p4_latency as *const _
                as usize
        },
        424usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_iio_buffer_malachite),
            "::",
            stringify!(p4_latency)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_iio_buffer_malachite>())).p5_latency as *const _
                as usize
        },
        432usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_iio_buffer_malachite),
            "::",
            stringify!(p5_latency)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_iio_buffer_malachite>())).p6_latency as *const _
                as usize
        },
        440usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_iio_buffer_malachite),
            "::",
            stringify!(p6_latency)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_iio_buffer_malachite>())).p7_latency as *const _
                as usize
        },
        448usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_iio_buffer_malachite),
            "::",
            stringify!(p7_latency)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct byteperf_upi_buffer_malachite {
    pub name: [::std::os::raw::c_char; 255usize],
    pub socket: ::std::os::raw::c_int,
    pub upi_rx_bandwidth: f64,
    pub upi_tx_bandwidth: f64,
    pub upi_tx_bandwidth_util: f64,
    pub upi_rx_latency: f64,
    pub upi_tx_latency: f64,
}
#[test]
fn bindgen_test_layout_byteperf_upi_buffer_malachite() {
    assert_eq!(
        ::std::mem::size_of::<byteperf_upi_buffer_malachite>(),
        304usize,
        concat!("Size of: ", stringify!(byteperf_upi_buffer_malachite))
    );
    assert_eq!(
        ::std::mem::align_of::<byteperf_upi_buffer_malachite>(),
        8usize,
        concat!("Alignment of ", stringify!(byteperf_upi_buffer_malachite))
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_upi_buffer_malachite>())).name as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_upi_buffer_malachite),
            "::",
            stringify!(name)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_upi_buffer_malachite>())).socket as *const _ as usize
        },
        256usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_upi_buffer_malachite),
            "::",
            stringify!(socket)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_upi_buffer_malachite>())).upi_rx_bandwidth as *const _
                as usize
        },
        264usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_upi_buffer_malachite),
            "::",
            stringify!(upi_rx_bandwidth)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_upi_buffer_malachite>())).upi_tx_bandwidth as *const _
                as usize
        },
        272usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_upi_buffer_malachite),
            "::",
            stringify!(upi_tx_bandwidth)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_upi_buffer_malachite>())).upi_tx_bandwidth_util
                as *const _ as usize
        },
        280usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_upi_buffer_malachite),
            "::",
            stringify!(upi_tx_bandwidth_util)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_upi_buffer_malachite>())).upi_rx_latency as *const _
                as usize
        },
        288usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_upi_buffer_malachite),
            "::",
            stringify!(upi_rx_latency)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_upi_buffer_malachite>())).upi_tx_latency as *const _
                as usize
        },
        296usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_upi_buffer_malachite),
            "::",
            stringify!(upi_tx_latency)
        )
    );
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct byteperf_count_buffer_malachite {
    pub cpu_num: ::std::os::raw::c_uint,
    pub cgroup_num: ::std::os::raw::c_uint,
    pub device_num: ::std::os::raw::c_uint,
    pub imc_num: ::std::os::raw::c_uint,
    pub iio_num: ::std::os::raw::c_uint,
    pub upi_num: ::std::os::raw::c_uint,
    pub power_num: ::std::os::raw::c_uint,
    pub l3_num: ::std::os::raw::c_uint,
    pub hardware: byteperf_hardware_malachite,
    pub cgroups: [byteperf_cgroup_buffer_malachite; 256usize],
    pub cpus: [byteperf_cpu_buffer_malachite; 256usize],
    pub imcs: [byteperf_imc_buffer_malachite; 24usize],
    pub iios: [byteperf_iio_buffer_malachite; 24usize],
    pub upis: [byteperf_upi_buffer_malachite; 24usize],
    pub powers: [byteperf_power_buffer_malachite; 24usize],
    pub l3cache: [byteperf_l3cache_buffer_malachite; 64usize],
}
#[test]
fn bindgen_test_layout_byteperf_count_buffer_malachite() {
    assert_eq!(
        ::std::mem::size_of::<byteperf_count_buffer_malachite>(),
        145248usize,
        concat!("Size of: ", stringify!(byteperf_count_buffer_malachite))
    );
    assert_eq!(
        ::std::mem::align_of::<byteperf_count_buffer_malachite>(),
        8usize,
        concat!("Alignment of ", stringify!(byteperf_count_buffer_malachite))
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_count_buffer_malachite>())).cpu_num as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_count_buffer_malachite),
            "::",
            stringify!(cpu_num)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_count_buffer_malachite>())).cgroup_num as *const _
                as usize
        },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_count_buffer_malachite),
            "::",
            stringify!(cgroup_num)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_count_buffer_malachite>())).device_num as *const _
                as usize
        },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_count_buffer_malachite),
            "::",
            stringify!(device_num)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_count_buffer_malachite>())).imc_num as *const _ as usize
        },
        12usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_count_buffer_malachite),
            "::",
            stringify!(imc_num)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_count_buffer_malachite>())).iio_num as *const _ as usize
        },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_count_buffer_malachite),
            "::",
            stringify!(iio_num)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_count_buffer_malachite>())).upi_num as *const _ as usize
        },
        20usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_count_buffer_malachite),
            "::",
            stringify!(upi_num)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_count_buffer_malachite>())).power_num as *const _
                as usize
        },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_count_buffer_malachite),
            "::",
            stringify!(power_num)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_count_buffer_malachite>())).l3_num as *const _ as usize
        },
        28usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_count_buffer_malachite),
            "::",
            stringify!(l3_num)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_count_buffer_malachite>())).hardware as *const _
                as usize
        },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_count_buffer_malachite),
            "::",
            stringify!(hardware)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_count_buffer_malachite>())).cgroups as *const _ as usize
        },
        1568usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_count_buffer_malachite),
            "::",
            stringify!(cgroups)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_count_buffer_malachite>())).cpus as *const _ as usize
        },
        81440usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_count_buffer_malachite),
            "::",
            stringify!(cpus)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_count_buffer_malachite>())).imcs as *const _ as usize
        },
        93728usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_count_buffer_malachite),
            "::",
            stringify!(imcs)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_count_buffer_malachite>())).iios as *const _ as usize
        },
        101408usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_count_buffer_malachite),
            "::",
            stringify!(iios)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_count_buffer_malachite>())).upis as *const _ as usize
        },
        112352usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_count_buffer_malachite),
            "::",
            stringify!(upis)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_count_buffer_malachite>())).powers as *const _ as usize
        },
        119648usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_count_buffer_malachite),
            "::",
            stringify!(powers)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<byteperf_count_buffer_malachite>())).l3cache as *const _ as usize
        },
        127328usize,
        concat!(
            "Offset of field: ",
            stringify!(byteperf_count_buffer_malachite),
            "::",
            stringify!(l3cache)
        )
    );
}
extern "C" {
    pub fn byteperf_update_cgroup_path(
        arg1: ::std::os::raw::c_int,
        cgroups_path: *mut [[::std::os::raw::c_char; 255usize]; 256usize],
    );
}
extern "C" {
    pub fn byteperf_setup_malachite(arg1: *mut byteperf_config_malachite) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn byteperf_destroy_malachite();
}
extern "C" {
    pub fn byteperf_gather_count_malachite(
        buffer: *mut byteperf_count_buffer_malachite,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn byteperf_check_module_health(
        profile_module: *mut ::std::os::raw::c_int,
        module_health: *mut ::std::os::raw::c_int,
    );
}

extern "C" {
    pub fn byteperf_module_control(mask: ::std::os::raw::c_int);
}
